#!/usr/bin/env python3
"""
用户偏好分析脚本

读取测试数据，生成用户画像分析报告。
支持 Stage 1 (基础分析) 和 Stage 2 (深度内容提取)。
"""

import os
import sys
import json
import logging
import argparse
from pathlib import Path

# 添加 event-processor 到 Python 路径
script_dir = Path(__file__).parent
project_root = script_dir.parent
sys.path.insert(0, str(project_root / 'event-processor'))

from analysis import SessionDetector, UserProfiler, ReportGenerator

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(message)s'
)
logger = logging.getLogger(__name__)


def load_test_events(test_case_path: str) -> list:
    """
    加载测试用例的事件数据

    Args:
        test_case_path: 测试用例文件路径或目录路径
                       - 如果是文件：直接读取（支持 JSON 数组）
                       - 如果是目录：读取目录下所有 JSON 文件

    Returns:
        事件列表
    """
    events = []
    test_path = Path(test_case_path)

    if not test_path.exists():
        raise FileNotFoundError(f"测试用例不存在: {test_case_path}")

    logger.info(f"📂 加载测试数据: {test_case_path}")

    # 情况1: 单个文件
    if test_path.is_file():
        logger.info(f"   检测到单个文件，文件大小: {test_path.stat().st_size / 1024 / 1024:.2f} MB")

        try:
            with open(test_path, 'r', encoding='utf-8') as f:
                content = f.read().strip()

                if not content:
                    raise ValueError("文件为空")

                # 解析 JSON
                event_data = json.loads(content)

                # 如果是数组，展开
                if isinstance(event_data, list):
                    events.extend(event_data)
                    logger.info(f"   文件包含 {len(event_data)} 个事件（JSON 数组格式）")
                else:
                    events.append(event_data)
                    logger.info(f"   文件包含 1 个事件（JSON 对象格式）")

        except json.JSONDecodeError as e:
            raise ValueError(f"JSON 解析失败: {e}")
        except Exception as e:
            raise ValueError(f"读取文件失败: {e}")

    # 情况2: 目录
    elif test_path.is_dir():
        json_files = sorted(test_path.glob('*.json'))
        logger.info(f"   发现 {len(json_files)} 个 JSON 文件")

        for json_file in json_files:
            try:
                with open(json_file, 'r', encoding='utf-8') as f:
                    content = f.read().strip()

                    if not content:
                        continue

                    event_data = json.loads(content)

                    if isinstance(event_data, list):
                        events.extend(event_data)
                    else:
                        events.append(event_data)

            except json.JSONDecodeError as e:
                logger.warning(f"⚠️  跳过无效的 JSON 文件: {json_file.name} - {e}")
                continue
            except Exception as e:
                logger.warning(f"⚠️  读取文件失败: {json_file.name} - {e}")
                continue

    else:
        raise ValueError(f"不支持的路径类型: {test_case_path}")

    logger.info(f"✅ 成功加载 {len(events)} 个事件")
    return events


def main():
    """主函数"""
    # 解析命令行参数
    parser = argparse.ArgumentParser(description='用户偏好分析工具')
    parser.add_argument(
        '--stage',
        type=int,
        choices=[1, 2],
        default=2,
        help='分析阶段: 1=基础分析(URL+Title), 2=深度内容提取(默认)'
    )
    parser.add_argument(
        '--test-case',
        type=str,
        default='test0001',
        help='测试用例名称 (默认: test0001)'
    )
    args = parser.parse_args()

    stage = args.stage
    stage_name = "Stage 1 (基础分析)" if stage == 1 else "Stage 2 (深度内容提取)"

    logger.info("=" * 60)
    logger.info(f"用户偏好分析 - {stage_name}")
    logger.info("=" * 60)
    logger.info("")

    # 1. 加载测试数据
    test_case_path = project_root / 'mock-data' / 'test-cases' / args.test_case
    try:
        events = load_test_events(str(test_case_path))
    except Exception as e:
        logger.error(f"❌ 加载测试数据失败: {e}")
        sys.exit(1)

    if not events:
        logger.error("❌ 没有找到有效的事件数据")
        sys.exit(1)

    logger.info("")

    # 2. 会话检测
    logger.info("🔍 阶段 1: 会话检测")
    detector = SessionDetector(gap_threshold_ms=5 * 60 * 1000)  # 5分钟
    sessions = detector.detect_sessions(events)
    logger.info(f"   检测到 {len(sessions)} 个独立会话")

    for i, session in enumerate(sessions, 1):
        duration_min = session['duration_sec'] / 60
        logger.info(
            f"   - 会话 {i}: {session['start_time_str']} - {session['end_time_str']} "
            f"({duration_min:.1f}分钟, {session['event_count']}个事件)"
        )

    logger.info("")

    # 3. URL 统计
    logger.info("📊 阶段 2: URL 访问统计")
    url_stats = detector.get_url_statistics(sessions)
    logger.info(f"   访问了 {len(url_stats)} 个不同的 URL")

    # 显示前 5 个
    top5 = sorted(url_stats, key=lambda x: x['total_duration_sec'], reverse=True)[:5]
    for i, stat in enumerate(top5, 1):
        title = stat['titles'][0] if stat['titles'] else 'N/A'
        logger.info(
            f"   {i}. {title[:40]}\n"
            f"      URL: {stat['url'][:60]}\n"
            f"      访问: {stat['visit_count']}次, 停留: {stat['total_duration_sec']}秒, 事件: {stat['event_count']}个"
        )

    logger.info("")

    # 4. 生成用户画像
    logger.info(f"🤖 阶段 3: 生成用户画像（调用 LLM - {stage_name}）")
    profiler = UserProfiler()

    if not profiler.is_available():
        logger.error("❌ LLM 未配置，无法生成用户画像")
        logger.error("   请设置环境变量: LLM_API_KEY")
        sys.exit(1)

    logger.info(f"   LLM Provider: {profiler.provider}")
    logger.info(f"   LLM Model: {profiler.model}")
    logger.info("   正在调用 LLM...")

    try:
        # 根据 stage 选择不同的方法
        if stage == 1:
            result = profiler.generate_profile(sessions, url_stats)
        else:  # stage == 2
            logger.info("   提取页面内容...")
            result = profiler.generate_profile_with_content(sessions, url_stats, events)
            if result.get('success'):
                logger.info(f"   ✅ 提取了 {result.get('content_extracted', 0)} 个页面的内容")

        if not result['success']:
            logger.error(f"❌ 生成用户画像失败: {result.get('error', 'Unknown error')}")
            sys.exit(1)

        profile = result['profile']
        logger.info("✅ 用户画像生成成功")
        logger.info("")

        # 显示画像摘要
        logger.info("   👤 用户画像:")
        logger.info(f"      职业: {profile.get('occupation', 'N/A')}")
        logger.info(f"      技能: {', '.join(profile.get('skills', []))}")
        logger.info(f"      兴趣: {', '.join(profile.get('interests', []))}")
        logger.info(f"      置信度: {profile.get('confidence', 0):.1%}")

        # Stage 2 专属：显示关键洞察
        if stage == 2 and 'key_insights' in profile:
            insights = profile.get('key_insights', [])
            if insights:
                logger.info("      关键洞察:")
                for insight in insights:
                    logger.info(f"        • {insight}")

        logger.info("")

    except Exception as e:
        logger.error(f"❌ 生成用户画像时出错: {e}")
        import traceback
        traceback.print_exc()
        sys.exit(1)

    # 5. 生成报告
    logger.info("📝 阶段 4: 生成分析报告")
    generator = ReportGenerator()

    # Markdown 报告
    markdown_report = generator.generate_markdown_report(
        sessions=sessions,
        url_stats=url_stats,
        profile=profile,
        events_count=len(events)
    )

    # JSON 报告
    json_report = generator.generate_json_report(
        sessions=sessions,
        url_stats=url_stats,
        profile=profile,
        events_count=len(events)
    )

    # 保存报告
    output_dir = project_root / 'output' / 'analysis'
    output_dir.mkdir(parents=True, exist_ok=True)

    # 文件名包含 stage 信息
    stage_suffix = f"_stage{stage}"

    # 保存 Markdown
    markdown_file = output_dir / f'user_profile_report{stage_suffix}.md'
    with open(markdown_file, 'w', encoding='utf-8') as f:
        f.write(markdown_report)
    logger.info(f"   ✅ Markdown 报告: {markdown_file}")

    # 保存 JSON
    json_file = output_dir / f'user_profile_report{stage_suffix}.json'
    with open(json_file, 'w', encoding='utf-8') as f:
        json.dump(json_report, f, ensure_ascii=False, indent=2)
    logger.info(f"   ✅ JSON 报告: {json_file}")

    # 保存 LLM 原始响应（调试用）
    llm_response_file = output_dir / f'llm_raw_response{stage_suffix}.txt'
    with open(llm_response_file, 'w', encoding='utf-8') as f:
        f.write(result.get('llm_response', ''))
    logger.info(f"   ✅ LLM 原始响应: {llm_response_file}")

    logger.info("")
    logger.info("=" * 60)
    logger.info("✅ 分析完成！")
    logger.info("=" * 60)
    logger.info("")
    logger.info("📖 查看报告:")
    logger.info(f"   Markdown: {markdown_file}")
    logger.info(f"   JSON: {json_file}")
    logger.info("")
    logger.info("💡 下一步:")
    logger.info("   1. 查看 Markdown 报告，评估分析效果")
    logger.info("   2. 如果效果满意，可以集成到数据处理流程")
    logger.info("   3. 如果需要更深入分析，可以升级到 Stage 2")
    logger.info("")


if __name__ == '__main__':
    main()
